home *** CD-ROM | disk | FTP | other *** search
/ Magnum One / Magnum One (Mid-American Digital) (Disc Manufacturing).iso / d14 / dde_lib.arc / ACCEXCEL.C < prev    next >
C/C++ Source or Header  |  1990-12-25  |  13KB  |  557 lines
  1. /* **********************************************************
  2.    accexcel.c - Access to Excell demo program
  3.  
  4.    Placed in public domain by Horizon Technologies Inc. 1990
  5.  
  6.   ***revision history***
  7. 1 ACCEXCEL.C 19-Jun-90,10:51:06,`JMH' Base version
  8. 2 ACCEXCEL.C 25-Jun-90,14:47:50,`JMH' Version as of 6/25/90
  9. 3 ACCEXCEL.C 15-Sep-90,16:36:10,`JMH' Version 1.3
  10.   ***revision history***
  11. ********************************************************** */
  12. #define MAIN
  13. #define NOCOMM
  14.  
  15. #include "windows.h"
  16. #include "dde.h"
  17. #include "ddelib.h"
  18. #include "string.h"
  19. #include "accexcel.h"
  20.  
  21. /* Undocumented windows functions */
  22. int FAR PASCAL lstrlen (LPSTR);
  23. LPSTR FAR PASCAL lstrcpy (LPSTR, LPSTR);
  24. LPSTR FAR PASCAL lstrcat (LPSTR, LPSTR);
  25. int FAR PASCAL lstrcmp (LPSTR, LPSTR);
  26.  
  27. /* Globals */
  28. static HANDLE ghInstance;
  29. static char *gszAppName = "accexcel";
  30. static char gszApp[40] = "excel";
  31. static char gszTopic[40] = "sheet1";
  32. static char gszItem[40] = "r1c1";
  33. static char gszData[80] = "7";
  34. static char gszCommand[80] = "[open(\"sheet2\")]";
  35. static int gcfFormat;
  36. static int fDeferUpd = FALSE;
  37. static int fAckReq = TRUE;
  38. static FARPROC glpfnCallBack;
  39.  
  40. /* Functions */
  41. int PASCAL WinMain (HANDLE, HANDLE, LPSTR, int);
  42. long FAR PASCAL WndProc (HWND, unsigned, WORD, LONG);
  43. BOOL FAR PASCAL Initiate (HWND, unsigned, WORD, LONG);
  44. BOOL FAR PASCAL Advise (HWND, unsigned, WORD, LONG);
  45. BOOL FAR PASCAL Unadvise (HWND, unsigned, WORD, LONG);
  46. BOOL FAR PASCAL Request (HWND, unsigned, WORD, LONG);
  47. BOOL FAR PASCAL Poke (HWND, unsigned, WORD, LONG);
  48. BOOL FAR PASCAL Execute (HWND, unsigned, WORD, LONG);
  49. BOOL FAR PASCAL About (HWND, unsigned, WORD, LONG);
  50. WORD FAR PASCAL CallBack (HWND, unsigned, LPSTR, HANDLE);
  51.  
  52.  
  53. int PASCAL WinMain (hInstance, hPrevInstance, lpCmdLine, nCmdShow)
  54. HANDLE hInstance;
  55. HANDLE hPrevInstance;
  56. LPSTR lpCmdLine;
  57. int nCmdShow;
  58. {
  59.    WNDCLASS wndclass;
  60.    MSG msg;
  61.    HWND hWnd;
  62.  
  63.    ghInstance = hInstance;
  64.  
  65.    if ( !hPrevInstance )
  66.       {
  67.       wndclass.style = CS_HREDRAW | CS_VREDRAW;
  68.       wndclass.lpfnWndProc = WndProc;
  69.       wndclass.cbClsExtra = 0;
  70.       wndclass.cbWndExtra = 0;
  71.       wndclass.hInstance = hInstance;
  72.       wndclass.hIcon = LoadIcon ( hInstance, gszAppName );
  73.       wndclass.hCursor = LoadCursor ( NULL, IDC_ARROW );
  74.       wndclass.hbrBackground = (HBRUSH) GetStockObject ( WHITE_BRUSH );
  75.       wndclass.lpszMenuName = gszAppName;
  76.       wndclass.lpszClassName = gszAppName;
  77.  
  78.       if ( !RegisterClass ( &wndclass ) )
  79.      return FALSE;
  80.       }  /* if ! hPrevInstance */
  81.  
  82.    hWnd = CreateWindow ( gszAppName, gszAppName, WS_OVERLAPPEDWINDOW,
  83.              CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, NULL, NULL,
  84.              hInstance, NULL );
  85.  
  86.    if ( !hWnd )
  87.       return ( NULL );
  88.  
  89.    ShowWindow ( hWnd, nCmdShow );
  90.    UpdateWindow ( hWnd );
  91.  
  92.    gcfFormat = RegisterClipboardFormat ( "csv" );
  93.    glpfnCallBack = MakeProcInstance ( CallBack, ghInstance );
  94.  
  95.    while ( GetMessage ( &msg, NULL, NULL, NULL ) )
  96.       {
  97.       TranslateMessage ( &msg );
  98.       DispatchMessage ( &msg );
  99.       }  /* while GetMessage */
  100.  
  101.    FreeProcInstance ( glpfnCallBack );
  102.  
  103.    return ( msg.wParam );
  104. }  /* function WinMain */
  105.  
  106.  
  107. long FAR PASCAL WndProc (hWnd, iMessage, wParam, lParam)
  108. HWND hWnd;
  109. unsigned iMessage;
  110. WORD wParam;
  111. LONG lParam;
  112. {
  113.    static HWND hClient = NULL;
  114.    FARPROC lpfnFunc;
  115.    DDEACK wAck;
  116.    HANDLE hCommand;
  117.    HANDLE hPoke;
  118.    LPSTR lpCommand;
  119.    LPDDEPOKE lpPoke;
  120.    DDEADVISE ddeAdvise;
  121.    int iRet;
  122.  
  123.    switch ( iMessage )
  124.       {
  125.       case WM_COMMAND:
  126.      switch ( wParam )
  127.         {
  128.         case IDM_EXIT:
  129.            SendMessage ( hWnd, WM_CLOSE, 0, 0L );
  130.            break;
  131.  
  132.         case IDM_ABOUT:
  133.            lpfnFunc = MakeProcInstance ( About, ghInstance );
  134.            DialogBox ( ghInstance, "About", hWnd, lpfnFunc );
  135.            FreeProcInstance ( lpfnFunc );
  136.            break;
  137.  
  138.         case IDM_INITIATE:
  139.            if ( hClient )
  140.           {
  141.           DDETerminate ( hClient );
  142.           hClient = NULL;
  143.           }  /* if hClient */
  144.  
  145.            lpfnFunc = MakeProcInstance ( Initiate, ghInstance );
  146.            iRet = DialogBox ( ghInstance, "Initiate", hWnd, lpfnFunc );
  147.            FreeProcInstance ( lpfnFunc );
  148.  
  149.            if ( iRet == IDOK )
  150.           {
  151.           hClient = DDEInitiate ( hWnd, gszApp, gszTopic );
  152.  
  153.           MessageBox ( hWnd, hClient ? "Session established" :
  154.                    "Initiate failed", "Initiate", MB_OK );
  155.           }  /* if iRet */
  156.            break;
  157.  
  158.         case IDM_ADVISE:
  159.            if ( !hClient )
  160.           break;
  161.  
  162.            lpfnFunc = MakeProcInstance ( Advise, ghInstance );
  163.            iRet = DialogBox ( ghInstance, "Advise", hWnd, lpfnFunc );
  164.            FreeProcInstance ( lpfnFunc );
  165.  
  166.            if ( iRet == IDOK )
  167.           {
  168.           /* Fill in the advise structure */
  169.           ddeAdvise.reserved = 0;
  170.           ddeAdvise.fDeferUpd = fDeferUpd;
  171.           ddeAdvise.fAckReq = fAckReq;
  172.           ddeAdvise.cfFormat = gcfFormat;
  173.  
  174.           *(WORD *) &wAck = DDEAdvise ( hClient, gszItem, &ddeAdvise,
  175.                         glpfnCallBack );
  176.  
  177.           MessageBox ( hWnd, wAck.fAck ? "Advise succeeded" :
  178.                    "Advise failed", "Advise", MB_OK );
  179.           }  /* if iRet */
  180.            break;
  181.  
  182.         case IDM_UNADVISE:
  183.            if ( !hClient )
  184.           break;
  185.  
  186.            lpfnFunc = MakeProcInstance ( Unadvise, ghInstance );
  187.            iRet = DialogBox ( ghInstance, "Unadvise", hWnd, lpfnFunc );
  188.            FreeProcInstance ( lpfnFunc );
  189.  
  190.            if ( iRet == IDOK )
  191.           {
  192.           *(WORD *) &wAck = DDEUnadvise ( hClient, gszItem );
  193.  
  194.           MessageBox ( hWnd, wAck.fAck ? "Unadvise succeeded" :
  195.                    "Unadvise failed", "Unadvise", MB_OK );
  196.           }  /* if iRet */
  197.            break;
  198.  
  199.         case IDM_REQUEST:
  200.            if ( !hClient )
  201.           break;
  202.  
  203.            lpfnFunc = MakeProcInstance ( Request, ghInstance );
  204.            iRet = DialogBox ( ghInstance, "Request", hWnd, lpfnFunc );
  205.            FreeProcInstance ( lpfnFunc );
  206.  
  207.            if ( iRet == IDOK )
  208.           {
  209.           *(WORD *) &wAck = DDERequest ( hClient, gszItem, gcfFormat,
  210.                          glpfnCallBack );
  211.  
  212.           MessageBox ( hWnd, wAck.fAck ? "Request succeeded" :
  213.                    "Request failed", "Request", MB_OK );
  214.           }  /* if iRet */
  215.            break;
  216.  
  217.         case IDM_POKE:
  218.            if ( !hClient )
  219.           break;
  220.  
  221.            lpfnFunc = MakeProcInstance ( Poke, ghInstance );
  222.            iRet = DialogBox ( ghInstance, "Poke", hWnd, lpfnFunc );
  223.            FreeProcInstance ( lpfnFunc );
  224.  
  225.            if ( iRet == IDOK )
  226.           {
  227.           hPoke = GlobalAlloc ( GHND | GMEM_DDESHARE, (DWORD) sizeof
  228.                     ( DDEPOKE ) + strlen ( gszData ) );
  229.  
  230.           /* Fill in the poke structure */
  231.           lpPoke = (LPDDEPOKE) GlobalLock ( hPoke );
  232.           lpPoke->fRelease = TRUE;
  233.           lpPoke->cfFormat = gcfFormat;
  234.           lstrcpy ( lpPoke->Value, gszData );
  235.           GlobalUnlock ( hPoke );
  236.  
  237.           *(WORD *) &wAck = DDEPoke ( hClient, gszItem, hPoke );
  238.  
  239.           MessageBox ( hWnd, wAck.fAck ? "Poke succeeded" :
  240.                    "Poke failed", "Poke", MB_OK );
  241.           }  /* if iRet */
  242.            break;
  243.  
  244.         case IDM_EXECUTE:
  245.            if ( !hClient )
  246.           break;
  247.  
  248.            lpfnFunc = MakeProcInstance ( Execute, ghInstance );
  249.            iRet = DialogBox ( ghInstance, "Execute", hWnd, lpfnFunc );
  250.            FreeProcInstance ( lpfnFunc );
  251.  
  252.            if ( iRet == IDOK )
  253.           {
  254.           hCommand = GlobalAlloc ( GHND | GMEM_DDESHARE, (DWORD)
  255.                        strlen ( gszCommand ) );
  256.  
  257.           /* Fill in the poke structure */
  258.           lpCommand = (LPSTR) GlobalLock ( hCommand );
  259.           lstrcpy ( lpCommand, gszCommand );
  260.           GlobalUnlock ( hCommand );
  261.  
  262.           *(WORD *) &wAck = DDEExecute ( hClient, hCommand );
  263.  
  264.           MessageBox ( hWnd, wAck.fAck ? "Execute succeeded" :
  265.                    "Execute failed", "Execute", MB_OK );
  266.           }  /* if iRet */
  267.            break;
  268.  
  269.         case IDM_TERMINATE:
  270.            if ( hClient )
  271.           {
  272.           DDETerminate ( hClient );
  273.           hClient = NULL;
  274.           }  /* if hClient */
  275.            break;
  276.         }  /* switch wParam */
  277.      break;
  278.  
  279.       case WM_DESTROY:
  280.      if ( hClient )
  281.         {
  282.         DDETerminate ( hClient );
  283.         hClient = NULL;
  284.         }  /* if hClient */
  285.      PostQuitMessage ( 0 );
  286.      break;
  287.  
  288.       default:
  289.      return DefWindowProc ( hWnd, iMessage, wParam, lParam );
  290.       }  /* switch iMessage */
  291.  
  292.    return 0L;
  293. }  /* function WndProc */
  294.  
  295.  
  296. /* Initiate box */
  297. BOOL FAR PASCAL Initiate (hDlg, iMessage, wParam, lParam)
  298. HWND hDlg;
  299. unsigned iMessage;
  300. WORD wParam;
  301. LONG lParam;
  302. {
  303.    switch ( iMessage )
  304.       {
  305.       case WM_INITDIALOG:
  306.      SetDlgItemText ( hDlg, IDD_APP, gszApp );
  307.      SetDlgItemText ( hDlg, IDD_TOPIC, gszTopic );
  308.      break;
  309.  
  310.       case WM_COMMAND:
  311.      switch ( wParam )
  312.         {
  313.         case IDOK:
  314.            GetDlgItemText ( hDlg, IDD_APP, gszApp, sizeof ( gszApp ) );
  315.            GetDlgItemText ( hDlg, IDD_TOPIC, gszTopic, sizeof ( gszTopic
  316.                 ) );
  317.            EndDialog ( hDlg, wParam );
  318.            break;
  319.  
  320.         case IDCANCEL:
  321.            EndDialog ( hDlg, wParam );
  322.            break;
  323.         }  /* switch wParam */
  324.      break;
  325.  
  326.       default:
  327.      return FALSE;
  328.       }  /* switch iMessage */
  329.    return TRUE;
  330. }  /* function Initiate */
  331.  
  332.  
  333. /* Advise box */
  334. BOOL FAR PASCAL Advise (hDlg, iMessage, wParam, lParam)
  335. HWND hDlg;
  336. unsigned iMessage;
  337. WORD wParam;
  338. LONG lParam;
  339. {
  340.    switch ( iMessage )
  341.       {
  342.       case WM_INITDIALOG:
  343.      SetDlgItemText ( hDlg, IDD_ITEM, gszItem );
  344.      break;
  345.  
  346.       case WM_COMMAND:
  347.      switch ( wParam )
  348.         {
  349.         case IDOK:
  350.            GetDlgItemText ( hDlg, IDD_ITEM, gszItem, sizeof ( gszItem ) );
  351.            EndDialog ( hDlg, wParam );
  352.            break;
  353.  
  354.         case IDCANCEL:
  355.            EndDialog ( hDlg, wParam );
  356.            break;
  357.         }  /* switch wParam */
  358.      break;
  359.  
  360.       default:
  361.      return FALSE;
  362.       }  /* switch iMessage */
  363.    return TRUE;
  364. }  /* function Advise */
  365.  
  366.  
  367. /* Unadvise box */
  368. BOOL FAR PASCAL Unadvise (hDlg, iMessage, wParam, lParam)
  369. HWND hDlg;
  370. unsigned iMessage;
  371. WORD wParam;
  372. LONG lParam;
  373. {
  374.    switch ( iMessage )
  375.       {
  376.       case WM_INITDIALOG:
  377.      SetDlgItemText ( hDlg, IDD_ITEM, gszItem );
  378.      break;
  379.  
  380.       case WM_COMMAND:
  381.      switch ( wParam )
  382.         {
  383.         case IDOK:
  384.            GetDlgItemText ( hDlg, IDD_ITEM, gszItem, sizeof ( gszItem ) );
  385.            EndDialog ( hDlg, wParam );
  386.            break;
  387.  
  388.         case IDCANCEL:
  389.            EndDialog ( hDlg, wParam );
  390.            break;
  391.         }  /* switch wParam */
  392.      break;
  393.  
  394.       default:
  395.      return FALSE;
  396.       }  /* switch iMessage */
  397.    return TRUE;
  398. }  /* function Unadvise */
  399.  
  400.  
  401. /* Request box */
  402. BOOL FAR PASCAL Request (hDlg, iMessage, wParam, lParam)
  403. HWND hDlg;
  404. unsigned iMessage;
  405. WORD wParam;
  406. LONG lParam;
  407. {
  408.    switch ( iMessage )
  409.       {
  410.       case WM_INITDIALOG:
  411.      SetDlgItemText ( hDlg, IDD_ITEM, gszItem );
  412.      break;
  413.  
  414.       case WM_COMMAND:
  415.      switch ( wParam )
  416.         {
  417.         case IDOK:
  418.            GetDlgItemText ( hDlg, IDD_ITEM, gszItem, sizeof ( gszItem ) );
  419.            EndDialog ( hDlg, wParam );
  420.            break;
  421.  
  422.         case IDCANCEL:
  423.            EndDialog ( hDlg, wParam );
  424.            break;
  425.         }  /* switch wParam */
  426.      break;
  427.  
  428.       default:
  429.      return FALSE;
  430.       }  /* switch iMessage */
  431.    return TRUE;
  432. }  /* function Request */
  433.  
  434.  
  435. /* Poke box */
  436. BOOL FAR PASCAL Poke (hDlg, iMessage, wParam, lParam)
  437. HWND hDlg;
  438. unsigned iMessage;
  439. WORD wParam;
  440. LONG lParam;
  441. {
  442.    switch ( iMessage )
  443.       {
  444.       case WM_INITDIALOG:
  445.      SetDlgItemText ( hDlg, IDD_ITEM, gszItem );
  446.      SetDlgItemText ( hDlg, IDD_DATA, gszData );
  447.      break;
  448.  
  449.       case WM_COMMAND:
  450.      switch ( wParam )
  451.         {
  452.         case IDOK:
  453.            GetDlgItemText ( hDlg, IDD_ITEM, gszItem, sizeof ( gszItem ) );
  454.            GetDlgItemText ( hDlg, IDD_DATA, gszData, sizeof ( gszData ) );
  455.            EndDialog ( hDlg, wParam );
  456.            break;
  457.  
  458.         case IDCANCEL:
  459.            EndDialog ( hDlg, wParam );
  460.            break;
  461.         }  /* switch wParam */
  462.      break;
  463.  
  464.       default:
  465.      return FALSE;
  466.       }  /* switch iMessage */
  467.    return TRUE;
  468. }  /* function Poke */
  469.  
  470.  
  471. /* Execute box */
  472. BOOL FAR PASCAL Execute (hDlg, iMessage, wParam, lParam)
  473. HWND hDlg;
  474. unsigned iMessage;
  475. WORD wParam;
  476. LONG lParam;
  477. {
  478.    switch ( iMessage )
  479.       {
  480.       case WM_INITDIALOG:
  481.      SetDlgItemText ( hDlg, IDD_COMMAND, gszCommand );
  482.      break;
  483.  
  484.       case WM_COMMAND:
  485.      switch ( wParam )
  486.         {
  487.         case IDOK:
  488.            GetDlgItemText ( hDlg, IDD_COMMAND, gszCommand,
  489.                 sizeof ( gszCommand ) );
  490.            EndDialog ( hDlg, wParam );
  491.            break;
  492.  
  493.         case IDCANCEL:
  494.            EndDialog ( hDlg, wParam );
  495.            break;
  496.         }  /* switch wParam */
  497.      break;
  498.  
  499.       default:
  500.      return FALSE;
  501.       }  /* switch iMessage */
  502.    return TRUE;
  503. }  /* function Execute */
  504.  
  505.  
  506. /* About box */
  507. BOOL FAR PASCAL About (hDlg, iMessage, wParam, lParam)
  508. HWND hDlg;
  509. unsigned iMessage;
  510. WORD wParam;
  511. LONG lParam;
  512. {
  513.    switch ( iMessage )
  514.       {
  515.       case WM_INITDIALOG:
  516.      break;
  517.  
  518.       case WM_COMMAND:
  519.      EndDialog ( hDlg, FALSE );
  520.      break;
  521.  
  522.       default:
  523.      return FALSE;
  524.       }  /* switch iMessage */
  525.    return TRUE;
  526. }  /* function About */
  527.  
  528.  
  529. /* Callback routine for advise circuit */
  530. WORD FAR PASCAL CallBack (hSession, iMessage, lpszItem, hData)
  531. HWND hSession;
  532. unsigned iMessage;
  533. LPSTR lpszItem;
  534. HANDLE hData;
  535. {
  536.    LPDDEDATA lpData;
  537.  
  538.  
  539.    switch ( iMessage )
  540.       {
  541.       case DDE_ACK:
  542.      break;
  543.  
  544.       case DDE_DATA:
  545.      /* Show the data */
  546.      lpData = (LPDDEDATA) GlobalLock ( hData );
  547.      MessageBox ( NULL, lpData->Value, lpszItem, MB_OK );
  548.      GlobalUnlock ( hData );
  549.      break;
  550.  
  551.       case DDE_TERMINATE:
  552.      break;
  553.       }
  554.  
  555.    return NULL;
  556. }  /* function CallBack */
  557.